package com.young.lib_fragments.utils

import android.Manifest
import android.content.Intent
import androidx.activity.result.ActivityResult
import androidx.activity.result.ActivityResultCallback
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContract
import androidx.activity.result.contract.ActivityResultContracts
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner

/**
 * @author huangzehui
 * @date 2025/1/26 16:51 周日
 * @description startActivityForResult 的替代方式辅助类
 *
 * startActivityForResult() 被弃用，来试试Activity Result API
 * https://blog.csdn.net/weixin_51906150/article/details/126589820
 *
 *
 * ActivityResultContract 默认封装好的一些常量类：
 *
 * StartActivityForResult: 通用的Contract,不做任何转换，Intent作为输入，ActivityResult作为输出，这也是最常用的一个协定。
 * RequestMultiplePermissions：用于请求一组权限
 * RequestPermission: 用于请求单个权限
 * TakePicturePreview: 调用MediaStore.ACTION_IMAGE_CAPTURE拍照，返回值为Bitmap图片
 * TakePicture: 调用MediaStore.ACTION_IMAGE_CAPTURE拍照，并将图片保存到给定的Uri地址，返回true表示保存成功。
 * TakeVideo: 调用MediaStore.ACTION_VIDEO_CAPTURE 拍摄视频，保存到给定的Uri地址，返回一张缩略图。
 * PickContact: 从通讯录APP获取联系人
 * GetContent: 提示用选择一条内容，返回一个通过ContentResolver#openInputStream(Uri)访问原生数据的Uri地址（content://形式） 。默认情况下，它增加了Intent#CATEGORY_OPENABLE, 返回可以表示流的内容。
 * CreateDocument: 提示用户选择一个文档，返回一个(file:/http:/content:)开头的Uri。
 * OpenMultipleDocuments: 提示用户选择文档（可以选择多个），分别返回它们的Uri，以List的形式。
 * OpenDocumentTree: 提示用户选择一个目录，并返回用户选择的作为一个Uri返回，应用程序可以完全管理返回目录中的文档。
 *
 * 也可以自定义，继承 ActivityResultContract ，就可以了，例如：
 *
 * class ResultContract extends ActivityResultContract<String, String> {
 *         @NonNull
 *         @Override
 *         public Intent createIntent(@NonNull Context context, String input) {
 *             Intent intent = new Intent(MainActivity.this, SecondActivity.class);
 *             intent.putExtra("come", input);
 *             return intent;
 *         }
 *
 *         @Override
 *         public String parseResult(int resultCode, @Nullable Intent intent) {
 *             return intent.getStringExtra("return");
 *         }
 *     }
 *
 * 注意：
 * 1、启动器的创建（createActivityResultLauncher），必须在 onCreate 创建，否则有异常
 *
 */
class RegisterForActivityResultUtil(lifecycle: Lifecycle) : LifecycleEventObserver {

    init {
        lifecycle.addObserver(this)
    }


    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_DESTROY -> {
                unRegisterAllLauncher()
                source.lifecycle.removeObserver(this)
            }

            else -> {}
        }
    }

    // 启动器集合
    private val mLauncherList = mutableListOf<ActivityResultLauncher<*>>()

    /**
     * 添加启动器
     */
    private fun addLauncher(launcher: ActivityResultLauncher<*>) {
        mLauncherList.add(launcher)
    }

    /**
     * 注销所有的启动器
     */
    private fun unRegisterAllLauncher() {
        if (mLauncherList.isEmpty()) {
            return
        }
        for (launcher in mLauncherList) {
            launcher.unregister()
        }
        mLauncherList.clear()
    }


    // 普通 activity 跳转 start

    /**
     * 创建一个activity的启动器
     *
     * @param activity Activity
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createActivityResultLauncher(
        activity: FragmentActivity,
        callback: ActivityResultCallback<ActivityResult>
    ): ActivityResultLauncher<Intent> {
        return createActivityResultLauncher(
            activity,
            ActivityResultContracts.StartActivityForResult(),
            callback
        )
    }


    /**
     * 创建一个activity的启动器
     *
     * @param activity Activity
     * @param contract 启动的协议（约束）
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun <I, O> createActivityResultLauncher(
        activity: FragmentActivity,
        contract: ActivityResultContract<I, O>,
        callback: ActivityResultCallback<O>
    ): ActivityResultLauncher<I> {
        return activity.registerForActivityResult(contract, callback).also {
            addLauncher(it)
        }
    }


    /**
     * 创建一个activity的启动器
     *
     * @param fragment Fragment对象
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createActivityResultLauncher(
        fragment: Fragment,
        callback: ActivityResultCallback<ActivityResult>
    ): ActivityResultLauncher<Intent> {
        return createActivityResultLauncher(
            fragment,
            ActivityResultContracts.StartActivityForResult(),
            callback
        )
    }

    /**
     * 创建一个activity的启动器
     *
     * @param fragment Fragment对象
     * @param contract 启动的协议（约束）
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun <I : Any, O> createActivityResultLauncher(
        fragment: Fragment,
        contract: ActivityResultContract<I, O>,
        callback: ActivityResultCallback<O>
    ): ActivityResultLauncher<I> {
        return fragment.registerForActivityResult(contract, callback).also {
            addLauncher(it)
        }
    }

    // 普通 activity 跳转 end


    // 权限请求 跳转 start

    /**
     * 创建单个权限的请求启动器
     *
     * @param activity Activity
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createSinglePermissionLauncher(
        activity: FragmentActivity,
        callback: ActivityResultCallback<Boolean>
    ): ActivityResultLauncher<String> {
        return createActivityResultLauncher(
            activity,
            ActivityResultContracts.RequestPermission(),
            callback
        )
    }

    /**
     * 创建单个权限的请求启动器
     *
     * @param fragment Fragment对象
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createSinglePermissionLauncher(
        fragment: Fragment,
        callback: ActivityResultCallback<Boolean>
    ): ActivityResultLauncher<String> {
        return createActivityResultLauncher(
            fragment,
            ActivityResultContracts.RequestPermission(),
            callback
        )
    }


    /**
     * 创建多个权限的请求启动器
     *
     * @param activity Activity
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createMultiplePermissionLauncher(
        activity: FragmentActivity,
        callback: ActivityResultCallback<Map<String, Boolean>>
    ): ActivityResultLauncher<Array<String>> {
        return createActivityResultLauncher(
            activity,
            ActivityResultContracts.RequestMultiplePermissions(),
            callback
        )
    }

    /**
     * 创建多个权限的请求启动器
     *
     * @param fragment Fragment对象
     * @param callback 回调，类似原本的 onActivityResult
     */
    fun createMultiplePermissionLauncher(
        fragment: Fragment,
        callback: ActivityResultCallback<Map<String, Boolean>>
    ): ActivityResultLauncher<Array<String>> {
        return createActivityResultLauncher(
            fragment,
            ActivityResultContracts.RequestMultiplePermissions(),
            callback
        )
    }

    /**
     * 请求单个权限
     *
     * @param launcher 启动器
     * @param permission 权限，例如：[Manifest.permission.CAMERA]
     */
    fun requestSinglePermission(launcher: ActivityResultLauncher<String>, permission: String) {
        launcher.launch(permission)
    }

    /**
     * 请求多个权限
     *
     * @param launcher 启动器
     * @param permissions 权限集合，例如：[Manifest.permission.CAMERA]
     */
    fun requestMultiplePermission(
        launcher: ActivityResultLauncher<Array<String>>,
        vararg permissions: String
    ) {
        if (permissions.isEmpty()) {
            throw Exception("please input your should request permission")
        }
        launcher.launch(arrayOf(*permissions))
    }

    // 权限请求 跳转 end

}